﻿//class CopyBan
//{
//	// ...
//private:
//	CopyBan(const CopyBan&);
//	CopyBan& operator=(const CopyBan&);
//	//...
//};

//class CopyBan
//{
//	// ...
//	CopyBan(const CopyBan&) = delete;
//	CopyBan& operator=(const CopyBan&) = delete;
//	//...
//};

//// 只能在堆上
//class HeapOnly
//{
//public:
//	template<class... Args>
//	static HeapOnly* CreateObj(Args&&... args)
//	{
//		//堆区new建立对象，在类中调用私有构造，因为这里的构造函数只能接收0或2个参数，这里模板参数包只能传0或2个参数
//		return new HeapOnly(args...);
//	}
//	//这里必须禁掉拷贝构造和赋值禁掉
//	HeapOnly(const HeapOnly&) = delete;
//	HeapOnly& operator=(const HeapOnly&) = delete;
//private:
//	//构造私有化
//	HeapOnly()
//	{}
//	HeapOnly(int x, int y)
//		:_x(x)
//		, _y(y)
//	{}
//
//	int _x = 0;
//	int _y = 0;
//};
//
//int main()
//{
//	//HeapOnly ho1;这里无法调用普通构造
//	//new会调用构造函数，这里无法调用私有构造，必须借助静态函数
//	//HeapOnly* ho2 = new HeapOnly;
//
//	//当调用CreateObj类中new出HeapOnly对象返回时，这里使用指针接收堆区已经建立的对象空间
//	HeapOnly* ho3 = HeapOnly::CreateObj();
//	HeapOnly* ho4 = HeapOnly::CreateObj(1, 1);
//
//	//HeapOnly copy(*ho3);没有禁掉拷贝构造和赋值的情况下这里会在栈区上建立对象
//	return 0;
//}

//// 只能在Stack
//class StackOnly
//{
//public:
//	template<class... Args>
//	static StackOnly CreateObj(Args&&... args)
//	{
//		//匿名对象构造，不能将拷贝构造禁掉，语法上是先构造再拷贝构造，即便优化了成了单单构造，但底层原理还是一样的
//		return StackOnly(args...);
//	}
//
//	//只将赋值运算符禁掉
//	//StackOnly(const StackOnly&) = delete;
//	StackOnly& operator=(const StackOnly&) = delete;
//
//	//拷贝构造没有被禁掉，可能导致堆区new一个对象，
//	//这里可采用专门重载一个类专属的operator new，然后将其禁掉，相当于不能使用new
//	void* operator new(size_t n) = delete; //operator new的第一个形参必须是size_t类型
//
//private:
//	// 构造私有化
//	StackOnly()
//	{}
//	StackOnly(int x, int y)
//		:_x(x)
//		, _y(y)
//	{}
//
//	int _x = 0;
//	int _y = 0;
//};
//
//int main()
//{
//	StackOnly so1 = StackOnly::CreateObj();
//	StackOnly so2 = StackOnly::CreateObj(1, 1);
//
//	//拷贝构造没有被禁掉，可能导致堆区建立，这里采用禁掉重载的operaotr new解决，使其不能使用new
//	//StackOnly* so3 = new StackOnly(so1); 
//	return 0;
//}

////只能在堆上，禁掉析构函数的方法，其余的不管
//class HeapOnly
//{
//public:
//	HeapOnly()
//	{}
//	HeapOnly(int x, int y)
//		:_x(x)
//		, _y(y)
//	{}
//
//	//方式一: 禁掉析构函数，使其不能自动调用，但不建议，因为析构都是要调用的，这里直接将其封死了
//	//~HeapOnly() = delete; 
//
//	//析构函数不能自动调用，因此不能再使用delete，这里使用Destroy函数释放空间
//	void Destroy()
//	{
//		delete this; //delete分为两部，先调用析构然后再free这块空间
//	}
//
//private:
//	//方式二: 析构函数私有化，也是使其不能自动调用，因为其私有化
//	~HeapOnly()
//	{
//		cout << "~HeapOnly()" << endl;
//	}
//
//	int _x;
//	int _y;
//};
//
//int main()
//{
//	//普通的调用均失败，因为这里生命周期结束时会自动调用析构函数，而析构函数被禁止或私有化了
//	//HeapOnly ho1;
//
//	//堆区建立对象，只会调用构造函数，不会自动调用析构函数，若不专门释放进程结束时全部销毁
//	HeapOnly* ptr1 = new HeapOnly;
//	ptr1->Destroy();
//
//  //智能指针的引入，必须使用删除器，因为这里类的析构不能调用了
//  shared_ptr<HeapOnly> ptr2(new HeapOnly, [](HeapOnly* ptr2) {ptr2->Destroy(); });
//	return 0;
//}

////C++98做法
//class NonInherit
//{
//public:
//	static NonInherit GetInstance()
//	{
//		return NonInherit();
//	}
//private:
//	NonInherit()
//	{}
//};
//
////C++11做法
//class NonInherit final
//{
//	// ....
//};

